fix(sticker): send WebP stickers as-is instead of re-encoding them - #166

Please address the comments from this code review:

## Overall Comments
- Consider replacing the bare `http.Get` in `stickerWebP` with a context-aware client (or passing through the existing request context) so sticker downloads respect timeouts and cancellations instead of potentially hanging indefinitely.
- The error message `"failed to convert image to WebP"` in `SendSticker` is now misleading when the input is already WebP and not re-encoded; updating it to something more generic like `"failed to prepare sticker payload"` would better reflect the new behavior.

## Individual Comments

### Comment 1
<location path="pkg/sendMessage/service/sticker_webp.go" line_range="38" />
<code_context>
+// A source that is already a valid WebP is returned untouched; anything else is decoded and
+// encoded to WebP as before.
+func stickerWebP(url string) ([]byte, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch image from URL: %v", err)
</code_context>
<issue_to_address>
**suggestion (bug_risk):** Consider using a context-aware HTTP client and checking the response status before reading the body.

This helper now does network I/O with `http.Get`, which uses the default client (no context, no timeout) and doesn’t validate the HTTP status. To avoid hangs and misinterpreting error pages as image data, please use a context-aware client (or one with a reasonable timeout, preferably passed in) and check `resp.StatusCode`, failing fast on non-2xx responses.

Suggested implementation:

```golang
import (
	"context"
	"fmt"
	"io"
	"net/http"
	"time"
)

// maxStickerBytes caps the sticker download. WhatsApp rejects stickers far smaller than this; the
// limit exists so a hostile URL cannot exhaust the process memory — relevant now that the payload
// is uploaded rather than decoded, so nothing downstream constrains its size either.
const maxStickerBytes = 10 << 20 // 10 MiB

// stickerWebP fetches the sticker URL and returns WebP bytes ready to upload.
//
// A source that is already a valid WebP is returned untouched; anything else is decoded and
// encoded to WebP as before.
func stickerWebP(url string) ([]byte, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create request for image URL: %v", err)
	}

	client := &http.Client{
		Timeout: 10 * time.Second,
	}

	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("failed to fetch image from URL: %v", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		return nil, fmt.Errorf("failed to fetch image from URL: unexpected HTTP status %s", resp.Status)
	}

	raw, err := io.ReadAll(io.LimitReader(resp.Body, maxStickerBytes+1))
	if err != nil {
		return nil, fmt.Errorf("failed to read image from URL: %v", err)
	}
	if len(raw) > maxStickerBytes {
		return nil, fmt.Errorf("sticker exceeds %d bytes", maxStickerBytes)
	}

```

The edit above assumes this file either had no explicit import block or can be safely updated to include `context`, `fmt`, `io`, `net/http`, and `time` together. If an import block already exists elsewhere in this file, adjust the edit so that:
1. You only add `context` and `time` to the existing `import (...)` block rather than reintroducing `fmt`, `io`, and `net/http`.
2. You avoid duplicating the `import` keyword or any existing imports.

If your project uses a shared or injected `*http.Client`, you may want to replace the inline `client := &http.Client{...}` with that shared client while keeping the `NewRequestWithContext` and status-code check logic intact.
</issue_to_address>